home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / CSS.php < prev    next >
Encoding:
PHP Script  |  2004-03-24  |  10.5 KB  |  347 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997 - 2003 The PHP Group                              |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author:  Klaus Guenther <klaus@capitalfocus.org>                     |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: CSS.php,v 1.1 2003/07/31 14:58:18 thesaur Exp $
  20.  
  21. require_once "HTML/Common.php";
  22.  
  23. /**
  24.  * Base class for CSS definitions
  25.  *
  26.  * This class handles the details for creating properly constructed CSS declarations.
  27.  *
  28.  * Example for direct output of stylesheet:
  29.  * <code>
  30.  * require_once 'HTML/CSS.php';
  31.  * 
  32.  * $css = new HTML_CSS();
  33.  * 
  34.  * // define styles
  35.  * $css->setStyle('body', 'background-color', '#0c0c0c');
  36.  * $css->setStyle('body', 'color', '#ffffff');
  37.  * $css->setStyle('h1', 'text-align', 'center');
  38.  * $css->setStyle('h1', 'font', '16pt helvetica, arial, sans-serif');
  39.  * $css->setStyle('p', 'font', '12pt helvetica, arial, sans-serif');
  40.  *
  41.  * // output the stylesheet directly to browser
  42.  * $css->display();
  43.  * </code>
  44.  *
  45.  * Example in combination with HTML_Page:
  46.  * <code>
  47.  * require_once 'HTML/Page.php';
  48.  * require_once 'HTML/CSS.php';
  49.  * 
  50.  * $css = new HTML_CSS();
  51.  * $css->setStyle('body', 'background-color', '#0c0c0c');
  52.  * $css->setStyle('body', 'color', '#ffffff');
  53.  * $css->setStyle('h1', 'text-align', 'center');
  54.  * $css->setStyle('h1', 'font', '16pt helvetica, arial, sans-serif');
  55.  * $css->setStyle('p', 'font', '12pt helvetica, arial, sans-serif');
  56.  *
  57.  * $p = new HTML_Page();
  58.  *
  59.  * $p->setTitle("My page");
  60.  * // it can be added as an object
  61.  * $p->addStyleDeclaration('text/css', &$css);
  62.  * $p->addMetaData("author", "My Name");
  63.  * $p->addBodyContent = "<h1>headline</h1>";
  64.  * $p->addBodyContent = "<p>some text</p>";
  65.  * $p->addBodyContent = "<p>some more text</p>";
  66.  * $p->addBodyContent = "<p>yet even more text</p>";
  67.  * $p->display();
  68.  * </code>
  69.  * 
  70.  * Example for generating inline code:
  71.  * <code>
  72.  * require_once 'HTML/CSS.php';
  73.  * 
  74.  * $css = new HTML_CSS();
  75.  * 
  76.  * $css->setStyle('body', 'background-color', '#0c0c0c');
  77.  * $css->setStyle('body', 'color', '#ffffff');
  78.  * $css->setStyle('h1', 'text-align', 'center');
  79.  * $css->setStyle('h1', 'font', '16pt helvetica, arial, sans-serif');
  80.  * $css->setStyle('p', 'font', '12pt helvetica, arial, sans-serif');
  81.  * $css->setSameStyle('body', 'p');
  82.  * 
  83.  * echo '<body style="' . $css->toInline('body') . '">';
  84.  * // will output:
  85.  * // <body style="font:12pt helvetica, arial, sans-serif;background-color:#0c0c0c;color:#ffffff;">
  86.  * </code>
  87.  *
  88.  * @author       Klaus Guenther <klaus@capitalfocus.org>
  89.  * @version      0.1.0
  90.  */
  91. class HTML_CSS extends HTML_Common {
  92.     
  93.     /**
  94.      * Contains the content of the <body> tag.
  95.      *
  96.      * @var     array
  97.      * @access  private
  98.      */
  99.     var $_css = array('body'=>array(
  100.                                     'background-color'=>'#ffffff'
  101.                                     ));
  102.     
  103.     /**
  104.      * Contains "alibis" (other elements that share a definition) of an element defined in CSS
  105.      *
  106.      * @var     array
  107.      * @access  private
  108.      */
  109.     var $_alibis = array();
  110.     
  111.     /**
  112.      * Controls caching of the page
  113.      *
  114.      * @var     bool
  115.      * @access  private
  116.      */
  117.     var $_cache = true;
  118.     
  119.     /**
  120.      * Contains the character encoding string
  121.      *
  122.      * @var     string
  123.      * @access  private
  124.      */
  125.     var $_charset = 'iso-8859-1';
  126.     
  127.     /**
  128.      * Class constructor
  129.      *
  130.      * @access  public
  131.      */
  132.     function HTML_CSS()
  133.     {
  134.         $commonVersion = 1.7;
  135.         if (HTML_Common::apiVersion() < $commonVersion) {
  136.             return PEAR::raiseError("HTML_CSS version " . $this->apiVersion() . " requires " .
  137.             "HTML_Common version 1.2 or greater.", 0, PEAR_ERROR_TRIGGER);
  138.         }
  139.     }
  140.     
  141.     /**
  142.      * Returns the current API version
  143.      *
  144.      * @access   public
  145.      * @returns  double
  146.      */
  147.     function apiVersion()
  148.     {
  149.         return 0.1;
  150.     } // end func apiVersion
  151.     
  152.     /**
  153.      * Sets or adds a CSS definition
  154.      *
  155.      * @param    string  $element   Element (or class) to be defined
  156.      * @param    string  $property  Property defined
  157.      * @param    string  $value     Value assigned
  158.      * @access   public
  159.      */
  160.     function setStyle ($element, $property, $value)
  161.     {
  162.         $this->_css[$element][$property]= $value;
  163.     } // end func setStyle
  164.     
  165.     /**
  166.      * Sets or adds a CSS definition
  167.      *
  168.      * @param    string  $element   Element (or class) to be defined
  169.      * @param    string  $others    Other elements that share the definitions, separated by commas
  170.      * @access   public
  171.      */
  172.     function setSameStyle ($others, $element)
  173.     {
  174.         $others =  explode(',', $others);
  175.         foreach ($others as $other) {
  176.             $other = trim($other);
  177.             $this->_css[$element]['other-elements'][] = $other;
  178.             $this->_alibis[$other][] = $element;
  179.         }
  180.     } // end func setSameStyle
  181.     
  182.     /**
  183.      * Defines if the document should be cached by the browser. Defaults to false.
  184.      *
  185.      * @param string $cache Options are currently 'true' or 'false'. Defaults to 'true'.
  186.      * @access public
  187.      */
  188.     function setCache($cache = 'true')
  189.     {
  190.         if ($cache == 'true'){
  191.             $this->_cache = true;
  192.         } else {
  193.             $this->_cache = false;
  194.         }
  195.     } // end func setCache
  196.     
  197.     /**
  198.      * Defines the charset for the file. defaults to ISO-8859-1 because of CSS1
  199.      * compatability issue for older browsers.
  200.      *
  201.      * @param string $type Charset encoding; defaults to ISO-8859-1.
  202.      * @access public
  203.      */
  204.     function setCharset($type = 'iso-8859-1')
  205.     {
  206.         $this->_charset = $type;
  207.     } // end func setCharset
  208.     
  209.     /**
  210.      * Returns the charset encoding string
  211.      *
  212.      * @access public
  213.      */
  214.     function getCharset()
  215.     {
  216.         return $this->_charset;
  217.     } // end func getCharset
  218.     
  219.     /**
  220.      * Generates and returns the array of CSS properties
  221.      *
  222.      * @return  array
  223.      * @access  public
  224.      */
  225.     function toArray()
  226.     {
  227.         return $this->_css;
  228.     } // end func toArray
  229.     
  230.     /**
  231.      * Generates and returns the CSS properties of an element or class as a string for inline use.
  232.      *
  233.      * @param   string  $element    Element or class for which inline CSS should be generated
  234.      * @return  string
  235.      * @access  public
  236.      */
  237.     function toInline($element)
  238.     {
  239.         
  240.         $strCss = '';
  241.         $newCssArray = '';
  242.         
  243.         // Iterate through the array of properties for the supplied element
  244.         // This allows for grouped elements definitions to work
  245.         if ($this->_alibis[$element]) {
  246.             $alibis = $this->_alibis[$element];
  247.             foreach ($alibis as $int => $newElement) {
  248.                 foreach ($this->_css[$newElement] as $key => $value) {
  249.                     if ($key != 'other-elements') {
  250.                         $newCssArray[$key] = $value;
  251.                     }
  252.                 }
  253.             }
  254.         }
  255.         
  256.         // The reason this comes second is because if something is defined twice,
  257.         // the value specifically assigned to this element should override
  258.         // values inherited from other element definitions
  259.         if ($this->_css[$element]) {
  260.             foreach ($this->_css[$element] as $key => $value) {
  261.                 if ($key != 'other-elements') {
  262.                     $newCssArray[$key] = $value;
  263.                 }
  264.             }
  265.         }
  266.         
  267.         foreach ($newCssArray as $key => $value) {
  268.             $strCss .= $key . ':' . $value . ";";
  269.         }
  270.         
  271.         // Let's roll!
  272.         return $strCss;
  273.     } // end func toInline
  274.     
  275.     /**
  276.      * Generates and returns the complete CSS as a string.
  277.      *
  278.      * @return string
  279.      * @access public
  280.      */
  281.     function toString()
  282.     {
  283.         
  284.         // get line endings
  285.         $lnEnd = $this->_getLineEnd();
  286.         $tabs = $this->_getTabs();
  287.         $tab = $this->_getTab();
  288.         
  289.         $strCss = '';
  290.         
  291.         // Allow a CSS comment
  292.         if ($this->_comment) {
  293.             $strCss = $tabs . '/* ' . $this->getComment() . ' */' . $lnEnd;
  294.         }
  295.         
  296.         // Iterate through the array and process each element
  297.         foreach ($this->_css as $element => $property) {
  298.             $strCss .= $lnEnd;
  299.             $alibis = '';
  300.             if (isset($property['other-elements']) && is_array($property['other-elements'])){
  301.                 foreach ($property['other-elements'] as $int => $other) {
  302.                     $alibis .= "$other, ";
  303.                 }
  304.             }
  305.             //start CSS element definition
  306.             $strCss .= $tabs . $alibis . $element . ' {' . $lnEnd;
  307.             
  308.             foreach ($property as $key => $value) {
  309.                 if ($key != 'other-elements') {
  310.                     $strCss .= $tabs . $tab . $key . ': ' . $value . ';' . $lnEnd;
  311.                 }
  312.             }
  313.             
  314.             // end CSS element definition
  315.             $strCss .= $tabs . '}' . $lnEnd;
  316.         }
  317.         
  318.         // Let's roll!
  319.         return $strCss;
  320.     } // end func toString
  321.     
  322.     /**
  323.      * Outputs the stylesheet to the browser.
  324.      *
  325.      * @access    public
  326.      */
  327.     function display()
  328.     {
  329.         
  330.         $lnEnd = $this->_getLineEnd();
  331.         
  332.         if(! $this->_cache) {
  333.             header("Expires: Tue, 1 Jan 1980 12:00:00 GMT");
  334.             header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
  335.             header("Cache-Control: no-cache");
  336.             header("Pragma: no-cache");
  337.         }
  338.         
  339.         // set character encoding
  340.         header("Content-Type: text/css; charset=" . $this->_charset);
  341.         
  342.         $strCss = $this->toString();
  343.         print $strCss;
  344.     } // end func display
  345.     
  346. }
  347. ?>